package com.neusoft.liduan.d0901;

public class Oop {
	/*	编程思想
	 * 		面向过程：逻辑从上到下，代码复用率不高。类比较少
	 * 		面向对象：一切都为对象。核心在于设计类和对象的使用
	 * 			比如：人
	 * 				属性有：姓名、性别、年龄等
	 * 				行为(方法)有：吃饭、睡觉、打游戏、学习等
	 * 			难点就在于设计类，方便的在于使用对象
	 * 			类与类的可以有直接关系，比如继承和实现
	 * 				类的继承是通过extends来实现的
	 * 				类的实现是通过implements来实现的
	 * 		类与对象之间关系
	 * 			类是对象的模板，类似于汽车设计图
	 * 			对象是类的实例，类似于根据设计图生产的汽车
	 * 	类的组成
	 * 		属性
	 * 		方法
	 * 		构造方法：创建对象，如果需要传入参数，可在构造方法中传并赋值给属性
	 * 			1、Java类默认都有一个无参的构造方法
	 * 			2、格式：权限修饰符 类名(形参列表){
	 * 				super();默认是隐藏的，调用父类的构造方法
	 * 				自定义的代码
	 * 				return;默认是隐藏的，返回
	 * 			}
	 * 			3、如果自定义了构造方法，则不会再默认提一个无参的构造方法
	 * 			4、构造方法支持方法重载，但不可以重写(Override)
	 * 		内部类：定义在类中的类
	 * 		代码块：也要初始化块，主要用于初始化属性的值
	 * 
	 * 		方法的重载
	 * 			1、方法名称相同
	 * 			2、方法的形参列表不同，包括形参类型和数量
	 * 			3、与方法的返回值类型和形参名无关
	 * 			4、方法的重载在调用时，以实参的类型和数量来确定方法
	 * 			好处在于，不用想太多的方法名称
	 * 
	 * 		代码块
	 * 			格式：{}
	 * 			作用：初始化属性值，支持修改常量的值
	 * 			了解代码块、静态代码以及构造方法的执行顺序
	 * 			静态代码块->代码块->构造方法
	 * 		常量
	 * 			常量是不允许 修改值的
	 * 			格式：权限修饰符 final static 数据类型 常量名 = 初始值;
	 * 
	 * 		内部类
	 * 			格式：权限修饰符 [static] class 类名{
	 * 				
	 * 				}
	 * 			可以直接使用外部类的方法及属性
	 * 			内部类的对象创建
	 * 				非静态内部类
	 * 					格式：外部类.内部类 实例名 = 外部类实例.new 内部类构造方法;
	 * 				静态内部类
	 * 					格式：外部类.内部类 实例名 = new 外部类.内部类构造方法;
	 */

	public static void main(String[] args) {
		Oop o = new Oop();
//		Oop o1 = new Oop(10, 30);
//		Oop o2 = new Oop("张三", 30);
//		Oop o3 = new Oop(10, 30, 40);
		
		//=左边定义变量，=右边创建对象
		//创建的对象一般称为实例(引用)，一个对象可以有多个实例
		Person p = new Person();
		p.name = "张三";
		p.gender = '男';
		p.age = 20;
		
		p.chifan();
		p.shuijiao();
		new Person();//匿名对象，是一次性使用的
		//在26行后面可以操作26行创建的对象，不能
		new Person().name = "hahja";
		
//		Oop.innerClass ic = new Oop.innerClass();错误
		Oop.InnerClass ic = o.new InnerClass();
		ic.show();
		System.out.println(o.age);
	}
	
	private int age;
	private final static String name = "hello";
	private final static String test;
	
	public class InnerClass{
		public void show() {
			age = 30;
			System.out.println("innerClass：：：" + age);
		}
	}

	{
		age = 20;
		System.out.println("代码块1");
	}
	
	{
		System.out.println("代码块2");
	}
	
	static {
		test = "hehe";
		System.out.println("静态代码块1");
	}
	
	static {
		System.out.println("静态代码块2");
	}
	
	public Oop(int a, int b) {
		System.out.println("int a, int b");
	}

	public Oop(int a, int b, int c) {
		System.out.println("int a, int b, int c");
	}
	
	public Oop(String b, int c) {
		System.out.println("String b, int c");
	}
	
	public Oop() {
		System.out.println("创建Oop对象");
	}
	
}
